package work.shenzhen;

import static java.lang.System.out;
import it.sauronsoftware.ftp4j.FTPClient;
import it.sauronsoftware.ftp4j.FTPException;
import it.sauronsoftware.ftp4j.FTPIllegalReplyException;

import java.io.File;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import work.utils.StandardClassUtils;

import com.h819.core.commons.Configurations;
import com.h819.core.db.MyDbUtils;
import com.h819.core.db.SqlUtils;
import com.h819.core.file.MyFileUtils;
import com.h819.core.file.excel.poi.POIUtils;
import com.h819.core.net.ftp.Ftp4jUtils;

/*
 本类用来处理深圳数据，应用之前，一定要看说明文件，备注信息详见   WebRoot/0_my_note/深圳数据处理/

 处理方法见："深圳数据导入.sql"

 如果导入平台，那么导入之前要验证一下标准号和标准类别，深圳给的数据比较乱，国内国外的标准混在一起

 在运行的时候，一定要在 plsql 工具中，把  oracle 的视图、序列和触发器打开，查看其是否可以工作。

 如果改变了表结构，会使视图或者触发器无法工作，需要再次编译一下，否则就不会触发  gateway 工作，就不会同步新插入的和更新的数据到 trs 数据库中。 

 先测试几条数据，查看 gateway 工作情况，正常之后，再大面积插入

 注意，如果用 flashfxp 上传文件，会自动改写文件扩展名大小写，导致文件找不到（在 flashfxp 中可以设置）。

 本类，操作的结果都默认设置在 D:\\00 中

 */

/*
 深圳数据结构说明

 深圳数据结构

 1.  excle 文件一 ：国内题录：指国内更新过的题录

 2.  excle 文件二 ： 国外题录1：文本更新过的题录（标志为：文本字段不为空），(也可能有同时题录更新)
 处理方法：直接插入或者覆盖题录和文本

 3.  excle 文件三： 国外题录2：仅题录更新过（标志为：文本字段为空）
 处理方法：直接覆盖原题录

 4. excle 文件四 ：更新统计

 处理：
 仅处理 2，3
 先处理 2 直接导入，之后处理 3 导入覆盖

 2012-02-01

 */

/*
 * 执行步骤：
 * 
 * writeNoPDF() 
 * creatTiluTXTFromExcelFiles() 
 * insertToOracleGW()
 * insertXGDToOracleGW() 
 * ftp ： 文件到 IB2
 * 
 * 
 * 最后，删除导入的 sae 题录，参见： 国外标准版权问题处理.sql

 * 注意：判断是否有数据，用 <>'' 而不是 is not null xgj 字段是这样
 */

public class ShenZhen extends ShenZhenBaseGW {

	private Logger log = Logger.getLogger(ShenZhen.class);
	PropertiesConfiguration conf = Configurations
			.getInstance("work.properties");
	private QueryRunner runner = new QueryRunner();
	private Connection conn = MyDbUtils.getInstance("work.properties")
			.getConnection("oracle.jdbc.driver.OracleDriver",
					conf.getString("jdbc.oracle.work.235.url"),
					conf.getString("jdbc.oracle.work.235.user"),
					conf.getString("jdbc.oracle.work.235.password"));

	// 根目录
	private String rootExcelFileDirectory = "d:\\00\\";

	// ===
	// 需要处理的集合：newTiLuSet，xgdONLY_BULTiLuSet，interNationalTiLuSet

	// 存放最终的，经过比较后的题录结果，这个结果需要进一步处理导入平台
	private String new_tilu = rootExcelFileDirectory + "new_tilu.txt";

	// 暂存标准号，用于比较剔除旧标准
	private String exception_old_tilu = rootExcelFileDirectory
			+ "exception_old_tilu.txt";

	// 存放非国际标准的题录，单独处理
	private String exception_not_international_tilu = rootExcelFileDirectory
			+ "exception_not_international_tilu.txt";

	// 存放包含 only 和 bul 的题录，应该放入修改单列表
	private String exception_onlybul_tilu = rootExcelFileDirectory
			+ "exception_onlybul_tilu.txt";

	// 暂存"标准号相同，语种不同"的题录，用于记录，经过修改后的题录已经加入 newTiLuSet 中
	private String exception_language_wrong_tilu = rootExcelFileDirectory
			+ "exception_language_wrong_tilu.txt";

	// 文本路径有问题的题录
	private String exception_textAddress_wrong = rootExcelFileDirectory
			+ "exception_textAddress_wrong.txt";

	// 暂存解析后的 pdf文件路径
	private String pdf_names = rootExcelFileDirectory + "pdf_names.txt";

	// 已经导入平台的题录
	private String finishedTiLuFile = rootExcelFileDirectory
			+ "finished_TiLu.txt";

	// 已经导入平台的题录，发生错误时
	private String finishedTiLuFileErr = rootExcelFileDirectory
			+ "finished_TiLuErr.txt";

	// 更新的题录，原文本变成孤立文件，单独到服务器上删除
	private String shouldDeleteFile = rootExcelFileDirectory
			+ "updateSqlShouldDelFileFromFtpServer_del.txt";

	// 更新的题录，原文本变成孤立文件，发生错误时
	private String shouldDeleteFileErr = rootExcelFileDirectory
			+ "updateSqlShouldDelFileFromFtpServer_delErr.txt";

	private List<String> gwClass = StandardClassUtils.getInstance()
			.getGWClassName();

	// 存放非 pdf 文件的名称
	private List<String> notPDF = new ArrayList<String>();

	/**
	 * 查找非 pdf 格式的文件。深圳给的数据有一些压缩文件，非pdf文件，发现过一次。
	 * 
	 * 同时把文件名和扩展名改为大写
	 * 
	 * 最终结果在 D 盘 00 目录中
	 * 
	 * @param rootDirectory
	 *            深圳数据，各月份文件夹的根目录
	 *            。I:\\深圳数据\\decryptPdfDirI:\\深圳数据\\decryptPdfDir
	 * 
	 */
	private void writeNoPDF(File rootDirectory) {

		// 找到非pdf附件
		findNoPDF(rootDirectory);

		// 输出结果，之后手工处理非pdf文件为pdf格式，修改excel中的对应关系
		try {
			FileUtils.writeLines(
					new File(rootExcelFileDirectory + "notPDF.txt"), notPDF);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/**
	 * 用来整理所有的待导入的题录，得到最终需要导入数据库的数据，并记录的文件中。
	 * 
	 * @param tiluFile
	 * @param exceptionTiluFileDerictory
	 */

	private void creatTiluTXTFromExcelFiles() {

		// "ONLY" 和 "BUL"
		// 1005.xls 1449,1450 行是个例子
		// 1004.xls 1003-1008 行，例子

		// 待比较的文件名，必须按照日期由近到远的顺序排列。如果有重复的标准，那么会保留最新的
		// 日期最近的是最新的修订过的标准，可能是题录更新，也可能是文本更新了。

		// 放在 rootExcelFileDirectory 文件夹中
		String file[] = { "2012.12.xls", "2012.11.xls" };

		// String file[] = { "000.xls" };

		// 根目录不存在
		if (!new File(rootExcelFileDirectory).exists()
				|| !new File(rootExcelFileDirectory).isDirectory())
			try {
				throw new IOException();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

		int fileSize = file.length;

		// 需要处理的集合：newTiLuSet，xgdONLY_BULTiLuSet，interNationalTiLuSet

		// 存放最终的，经过比较的题录结果，这个结果需要进一步处理后导入平台
		Set<String> newTiLuSet = new TreeSet<String>();

		// 存放包含 only 和 bul 的题录，应该放入修改单列表
		Set<String> xgdONLY_BULTiLuSet = new TreeSet<String>();

		// 暂存标准号，用于比较剔除旧标准
		Set<String> stdCodeTempSet = new TreeSet<String>();

		// 暂存"标准号相同，语种不同"的题录，用于记录，经过修改后的题录已经加入 newTiLuSet 中
		Set<String> languageTiLuSet = new TreeSet<String>();

		// 存放非国际标准的题录，单独处理
		Set<String> interNationalTiLuSet = new TreeSet<String>();

		// 存放找到的旧的被更新的标准
		Set<String> setOldTiLu = new TreeSet<String>();

		// 存放文本路径标注错误的题录
		Set<String> wrongTextAddress = new TreeSet<String>();

		/**
		 * 
		 * 用 tree 来过滤重复的标准，通过比较标准号是否相同。
		 * 
		 */
		for (int i = 0; i < fileSize; i++) {

			// 最近一个月数据
			Set<String> setTemp = POIUtils.readExcel(new File(
					rootExcelFileDirectory + file[i]));

			// log.info(file[i] + " size:" + tempSet.size());

			// 提取最近一个月的题录的标准号，放入 set 中，便于和上一个月进行比较
			for (String lineValue : setTemp) {

				// 去掉乱码，最主要的就这几个
				lineValue = StringUtils.remove(lineValue, "癈");
				lineValue = StringUtils.remove(lineValue, "癋");

				lineValue = StringUtils.remove(lineValue, "?");
				lineValue = StringUtils.remove(lineValue, "鈥");
				lineValue = StringUtils.remove(lineValue, "■");

				// 通过比较标准号，挑选题录
				String stdCodeValue = POIUtils.getColumValue(lineValue, 0);

				// only,bul 特殊文件名处理
				String stdFileName = POIUtils.getColumValue(lineValue, 20)
						.toLowerCase();

				// 文件路径不合法
				if (StringUtils.countMatches(stdFileName.replace("\\", "/"),
						"/") > 1) {

					wrongTextAddress.add(lineValue);
				}

				// 标准类别
				String classCodeValue = POIUtils.getColumValue(lineValue, 3);

				// 不处理没有文本的题录
				if (stdFileName == null)
					continue;

				// 跳过第一行
				if (stdCodeValue.equals("stdid"))
					continue;

				// 不处理国内的标准，首标网也在维护这几类，用自己的数据
				if (classCodeValue.equals("JJG")
						|| classCodeValue.equals("JJF")
						|| classCodeValue.equals("DB33"))
					continue;

				// out.println(gwClass);

				// out.println(classCodeValue);

				// 剔除非国际标准
				if (!gwClass.contains(classCodeValue)) {

					// log.info(classCodeValue);

					// 更正深圳的错误标注
					if (stdCodeValue.startsWith("ISO/IEC")) {
						lineValue = POIUtils.replaceColumValue(lineValue, 3,
								"ISO");
					} else {
						interNationalTiLuSet.add("非国际标准 ：" + lineValue);
						continue;
					}
				}

				// 替换文本路径字段，文本路径变为：年月号+组织名称+文本文件名称

				// 和光盘保持一致，这样便于按照光盘的组织模式直接导入文本文件。

				//

				// 此时excel文件名称必须为 2010.01(10年01月),2010.02(10年02月)

				// 最后文本路径的形式为 2010.06/IEC/IEC60034-2-2Y2010(EF).PDF

				// 由于在 findNoPDF 函数中，文件夹和文件都修改为大写，所以此处文本字段都变为大写

				// log.info(POIUtils.getColumValue(lineValue, 20));

				String textAddress = StringUtils.substringBeforeLast(
						POIUtils.getFileName(lineValue), ".")
						+ "\\"
						+ POIUtils.getColumValue(lineValue, 20).toUpperCase();

				lineValue = POIUtils.replaceColumValue(lineValue, 20,
						textAddress);

				// 如果摘要过长，数据库存储不了，则截取部分
				String summary = POIUtils.getColumValue(lineValue, 18);

				if (StringUtils.length(summary) > 1999) {
					lineValue = POIUtils.replaceColumValue(lineValue, 18,
							StringUtils.substring(summary, 0, 1999));
				}

				/*
				 * 对于多语种的标准，同一个标准号会有会有多个，仅是语种不同。由于首标网标准号唯一，所以不能直接入库
				 * 
				 * 做如下处理：非英语的标准，标准号后面添加语种标识，不影响查询，日后可进行进一步处理。
				 * 
				 * 之后直接导入数据库
				 */

				// 无标准正文的修改单的情况，包含特定字母 "only"和"bul"
				if (StringUtils.contains(stdFileName, "only")
						|| StringUtils.contains(stdFileName, "bul")) {

					// 处理特殊语种
					// FR 法文
					if (StringUtils.contains(stdFileName, "(fr)")) {
						// 修正深圳错误
						lineValue = POIUtils.replaceColumValue(lineValue, 16,
								"FR");
						// 标准号做修改
						lineValue = POIUtils.replaceColumValue(lineValue, 0,
								stdCodeValue + "(FR)");
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}
					// DE 德文
					else if (StringUtils.contains(stdFileName, "(de)")) {
						// 修正深圳错误
						lineValue = POIUtils.replaceColumValue(lineValue, 16,
								"DE");
						// 标准号做修改
						lineValue = POIUtils.replaceColumValue(lineValue, 0,
								stdCodeValue + "(DE)");
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}
					// JA 日文
					else if (StringUtils.contains(stdFileName, "(ja)")) {
						// 修正深圳错误
						lineValue = POIUtils.replaceColumValue(lineValue, 16,
								"JA");
						// 标准号做修改
						lineValue = POIUtils.replaceColumValue(lineValue, 0,
								stdCodeValue + "(JA)");
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}

					// EF 英法双语
					else if (StringUtils.contains(stdFileName, "(ef)")) {
						// 修正深圳错误
						lineValue = POIUtils.replaceColumValue(lineValue, 16,
								"EF");
						// 标准号做修改
						lineValue = POIUtils.replaceColumValue(lineValue, 0,
								stdCodeValue + "(EF)");
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}

					// EFR 英法俄三语
					else if (StringUtils.contains(stdFileName, "(efr)")) {
						// 修正深圳错误
						lineValue = POIUtils.replaceColumValue(lineValue, 16,
								"EFR");
						// 标准号做修改
						lineValue = POIUtils.replaceColumValue(lineValue, 0,
								stdCodeValue + "(EFR)");
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}
					// 为英语，不做标记
					else {
						xgdONLY_BULTiLuSet.add("不包括正文的修改单,需要导入数据库修改单表 ："
								+ lineValue);
						continue;
					}
				}

				// 处理特殊语种
				// FR 法文
				if (StringUtils.contains(stdFileName, "(fr)")) {
					// 修正深圳错误
					lineValue = POIUtils.replaceColumValue(lineValue, 16, "FR");
					// 标准号做修改
					lineValue = POIUtils.replaceColumValue(lineValue, 0,
							stdCodeValue + "(FR)");
					languageTiLuSet.add(lineValue);
					newTiLuSet.add(lineValue);
					stdCodeTempSet.add(stdCodeValue + "(FR)");
					continue;
				}
				// DE 德文
				if (StringUtils.contains(stdFileName, "(de)")) {
					// 修正深圳错误
					lineValue = POIUtils.replaceColumValue(lineValue, 16, "DE");
					// 标准号做修改
					lineValue = POIUtils.replaceColumValue(lineValue, 0,
							stdCodeValue + "(DE)");
					// out.println(lineValue);
					languageTiLuSet.add(lineValue);
					newTiLuSet.add(lineValue);
					stdCodeTempSet.add(stdCodeValue + "(DE)");
					continue;
				}
				// JA 日文
				if (StringUtils.contains(stdFileName, "(ja)")) {
					// 修正深圳错误
					lineValue = POIUtils.replaceColumValue(lineValue, 16, "JA");
					// 标准号做修改
					lineValue = POIUtils.replaceColumValue(lineValue, 0,
							stdCodeValue + "(JA)");
					languageTiLuSet.add(lineValue);
					newTiLuSet.add(lineValue);
					stdCodeTempSet.add(stdCodeValue + "(JA)");
					continue;
				}

				// EF 英法双语
				if (StringUtils.contains(stdFileName, "(ef)")) {
					// log.info("stdFileName: "+stdFileName);
					// log.info("lineValue0: "+lineValue);
					// 修正深圳错误
					lineValue = POIUtils.replaceColumValue(lineValue, 16, "EF");
					// log.info("lineValue1: "+lineValue);
					// 标准号做修改
					lineValue = POIUtils.replaceColumValue(lineValue, 0,
							stdCodeValue + "(EF)");
					// log.info("lineValue2: "+lineValue);
					languageTiLuSet.add(lineValue);
					newTiLuSet.add(lineValue);
					stdCodeTempSet.add(stdCodeValue + "(EF)");
					continue;
				}

				// EFR 英法俄三语
				if (StringUtils.contains(stdFileName, "(efr)")) {
					// 修正深圳错误
					lineValue = POIUtils
							.replaceColumValue(lineValue, 16, "EFR");
					// 标准号做修改
					lineValue = POIUtils.replaceColumValue(lineValue, 0,
							stdCodeValue + "(EFR)");
					languageTiLuSet.add(lineValue);
					newTiLuSet.add(lineValue);
					stdCodeTempSet.add(stdCodeValue + "(EFR)");
					continue;
				}

				// 最近的标准，已经包含，标识最近被更新过的标准，记录并跳过
				if (stdCodeTempSet.contains(stdCodeValue)) {
					// 查看文本的语种，非英文的挑选出来。深圳用"(DE)" ,DE 为语种代码，标注了，故判断是否包含")"即可。
					setOldTiLu.add("已存在题录,不需要导入：" + lineValue);
					continue;
				}

				// 其他情况，是新标准，做好记录
				// 题录数据加入最终结果
				newTiLuSet.add(lineValue);
				// 标准号加入待比较集合
				stdCodeTempSet.add(stdCodeValue);
			}
		}

		// 测试最终结果
		// for (String setValue : setNewTiLu)
		// log.info(setValue);

		// 测试被更新的标准
		// for (String setValue : setOldTiLu)
		// log.info(setValue);

		// 生成最终结果
		try {

			// 挑选出来的最终题录
			if (!newTiLuSet.isEmpty())
				FileUtils.writeLines(new File(new_tilu), newTiLuSet);

			// 被更新过的题录，跳过不处理
			if (!setOldTiLu.isEmpty())
				FileUtils.writeLines(new File(exception_old_tilu), setOldTiLu);

			// 非国际标准，挑选出来，处理不需要导入首标网。
			if (!interNationalTiLuSet.isEmpty())
				FileUtils.writeLines(
						new File(exception_not_international_tilu),
						interNationalTiLuSet);

			// 包含 only 和 bul 的题录
			if (!xgdONLY_BULTiLuSet.isEmpty())
				FileUtils.writeLines(new File(exception_onlybul_tilu),
						xgdONLY_BULTiLuSet);

			// 语言不同，标准号相同的题录，已经把语言代码加到标准号中，放进了最终待处理的集合 newTiLuSet，不用处理
			if (!languageTiLuSet.isEmpty())
				FileUtils.writeLines(new File(exception_language_wrong_tilu),
						languageTiLuSet);

			// 文本路径有问题的题录
			if (!wrongTextAddress.isEmpty())
				FileUtils.writeLines(new File(exception_textAddress_wrong),
						wrongTextAddress);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		log.info("需要处理：非国际标准，修正后重新生成题录:" + interNationalTiLuSet.size());
		log.info("需要处理：导入题录表   : " + newTiLuSet.size());
		log.info("需要处理：导入的修改单表(包含 only ,bul ) :" + xgdONLY_BULTiLuSet.size());
		log.info("需要处理：文本路径有问题的题录，文件不在根目录下，一般是在“CENELEC”目录下的文件，写成了在“ CEN\\CENELEC”下。核对文件具体位置，修改 excle 中文件路径后，重新生成待导入题录直至该项操作结果为 0:"
				+ wrongTextAddress.size());
		log.info("不需要处理：老题录，被新的题录代替:" + setOldTiLu.size());

	}

	/**
	 * 导入国外标准。国内标准由于逻辑不同，单独处理，不用此方法
	 * 
	 * 在正式运行前，关闭数据库操作语句进行测试，检查 sql 文件没有问题后再进行操作
	 * 
	 * @param tiluFile
	 *            题录信息
	 */

	private void insertToOracleGW(File tiluFile) {

		// === 深圳国内题录所有记录项，共 21项
		// === 经过检查，深圳国外题录项和国内的一致
		// 字段名称+excel 列号

		// String stdid0 = "";// 标准号
		// String stdcn1 = "";// 中文名称
		// String stden2 = "";// 英文名称
		// String stdorg3 = "";// 标准类别(标准组织缩写)
		//
		// String stdstate4 = "";// 标准状态
		// String stdfbdate5 = "";// 发布日期
		// String stdssdate6 = "";// 实施日期
		// String stdfzdate7 = "";// 废止日期
		// String gbfl8 = "";// ccs(国家标准分类)
		// String icsfl9 = "";// ics(国际标准分类)
		// String xgj10 = "";// 修改件(修改单)
		// String tdbz11 = "";// 代替标准
		// String btdbz12 = "";// 被代替标准
		// String yybz13 = "";// 引用标准
		// String cybz14 = "";// 采用标准
		// String kword15 = "";// 关键字
		// String language16 = "";// 语种
		// String page17 = "";// 页数
		// String summary18 = "";// 摘要
		// String opdate19 = "";// 操作时间
		// String pdfname20 = "";// pdf 文件路径

		List<String> tiluList = null;

		// 保存已经导入的题录
		Set<String> finishedTiLu = new TreeSet<String>();
		// 保存已经导入应该删除的孤立文件
		Set<String> delFileFromFtpServerSet = new TreeSet<String>();
		// 保存已经导入的题录,发生错误时
		Set<String> finishedTiLuErr = new TreeSet<String>();
		// 保存已经导入应该删除的孤立文件，发生错误时
		Set<String> delFileFromFtpServerSetErr = new TreeSet<String>();

		int countUpdate = 0;
		int countInsert = 0;

		int n = 0;
		int h = 0;

		try {

			tiluList = FileUtils.readLines(tiluFile);

			if (tiluList == null)
				return;

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		for (String lineValue : tiluList) {

			// 测试10条数据
			// n++;
			// log.info("n = " + n);
			// if (n == 10)
			// break;
			// 测试

			out.println(StringUtils.center(" line ", 80, "*"));

			// 如果字段值没有，会自动返回 null，不会影响 sql 语句执行
			// id
			String id = "seq_standard.nextval";
			// 标准号
			String standard_code = POIUtils.getColumValue(lineValue, 0);
			if (standard_code != null)
				standard_code = "'"
						+ SqlUtils.getInstance().getEscapeVale(standard_code)
						+ "'";

			if (standard_code == null)
				standard_code = " ";

			// 英文名称
			String nameen = POIUtils.getColumValue(lineValue, 2);
			if (nameen != null)
				nameen = "'" + SqlUtils.getInstance().getEscapeVale(nameen)
						+ "'";
			else
				nameen = "' '";

			if (nameen == null)
				nameen = " ";

			// 中文名称，如果为空，则默认为 英文名称
			String namecn = POIUtils.getColumValue(lineValue, 1);
			if (namecn != null)
				namecn = "'" + SqlUtils.getInstance().getEscapeVale(namecn)
						+ "'";
			else
				namecn = nameen;

			if (namecn == null || namecn.equals("''"))
				namecn = nameen;

			// 标准类别(标准组织缩写)
			String class_two_code = POIUtils.getColumValue(lineValue, 3);
			if (class_two_code != null)
				class_two_code = "'"
						+ SqlUtils.getInstance().getEscapeVale(class_two_code)
						+ "'";

			// 标准状态
			String status = this.getUpdateStateCode(POIUtils.getColumValue(
					lineValue, 4));
			if (status != null)
				status = "'" + SqlUtils.getInstance().getEscapeVale(status)
						+ "'";

			if (status == null)
				status = " ";

			// 发布日期
			String issue_time = POIUtils.getColumValue(lineValue, 5);
			if (issue_time != null)
				issue_time = "to_date('"
						+ SqlUtils.getInstance().getEscapeVale(issue_time)
						+ "','yyyy-mm-dd')";

			// 实施日期
			String act_time = POIUtils.getColumValue(lineValue, 6);
			if (act_time != null)
				act_time = "to_date('"
						+ SqlUtils.getInstance().getEscapeVale(act_time)
						+ "','yyyy-mm-dd')";

			// 废止日期
			String cancel_time = POIUtils.getColumValue(lineValue, 7);
			if (cancel_time != null)
				cancel_time = "to_date('"
						+ SqlUtils.getInstance().getEscapeVale(cancel_time)
						+ "','yyyy-mm-dd')";

			// ccs(国家标准分类)
			String ccs_code = POIUtils.getColumValue(lineValue, 8);
			if (ccs_code != null)
				ccs_code = "'" + SqlUtils.getInstance().getEscapeVale(ccs_code)
						+ "'";

			// ics(国际标准分类)
			String ics_code = POIUtils.getColumValue(lineValue, 9);
			if (ics_code != null)
				ics_code = "'" + SqlUtils.getInstance().getEscapeVale(ics_code)
						+ "'";

			// 修改件(这里这个字段，是后加的，为了记录深圳数据)
			String xgj = POIUtils.getColumValue(lineValue, 10);
			if (xgj != null)
				xgj = "'" + SqlUtils.getInstance().getEscapeVale(xgj) + "'";

			// 代替标准
			String replace_standard = this.getUpdateDtbzCode(POIUtils
					.getColumValue(lineValue, 11));
			if (replace_standard != null)
				replace_standard = "'"
						+ SqlUtils.getInstance()
								.getEscapeVale(replace_standard) + "'";

			// 被代替标准
			String replaced_standard = this.getUpdateDtbzCode(POIUtils
					.getColumValue(lineValue, 12));
			if (replaced_standard != null)
				replaced_standard = "'"
						+ SqlUtils.getInstance().getEscapeVale(
								replaced_standard) + "'";

			// 引用标准
			String reference_file = POIUtils.getColumValue(lineValue, 13);
			if (reference_file != null)
				reference_file = "'"
						+ SqlUtils.getInstance().getEscapeVale(reference_file)
						+ "'";

			// 采用标准
			String adopt_standard_code = this.getUpdateCybzCode(POIUtils
					.getColumValue(lineValue, 14));
			if (adopt_standard_code != null)
				adopt_standard_code = "'"
						+ SqlUtils.getInstance().getEscapeVale(
								adopt_standard_code) + "'";

			// 关键字
			String topic = POIUtils.getColumValue(lineValue, 15);
			if (topic != null)
				topic = "'" + SqlUtils.getInstance().getEscapeVale(topic) + "'";

			// 语种
			String language_code = this.getUpdateLanguageCode(POIUtils
					.getColumValue(lineValue, 16));
			if (language_code != null)
				language_code = "'"
						+ SqlUtils.getInstance().getEscapeVale(language_code)
						+ "'";

			// 页数
			String page_number = POIUtils.getColumValue(lineValue, 17);
			if (page_number != null)
				page_number = "'"
						+ SqlUtils.getInstance().getEscapeVale(page_number)
						+ "'";

			// 摘要
			String summary = POIUtils.getColumValue(lineValue, 18);
			if (summary != null)
				summary = "'" + SqlUtils.getInstance().getEscapeVale(summary)
						+ "'";

			// 最后修改时间
			String lasted_modify_time = "sysdate";

			// 文本路径
			String text_address = this.getUpdateTextAddress(POIUtils
					.getColumValue(lineValue, 20));
			if (text_address != null)
				text_address = "'"
						+ SqlUtils.getInstance().getEscapeVale(text_address)
						+ "'";

			String lasted_user = "'" + "ShenZhen" + "'";
			// String remark = "'" + "深圳国外数据导入" + "'";

			// === 调整后的字段值：

			// 一级分类统一为国外
			String class_one_code = "";
			String class_three_code = null;

			String remarkString = ",";

			if (class_two_code != null)
				if (class_two_code.equals("'JJG'")
						|| class_two_code.equals("'JJF'"))
					class_one_code = "'GN'";
				else if (class_two_code.equals("'DB33'")) {
					class_one_code = "'GN'";
					class_two_code = "'DB'";
					class_three_code = "'DB33'";
				} else
					class_one_code = "'GW'";

			String selectSql = "select remark,TEXT_ADDRESS from st_standard t where t.standard_code ="
					+ standard_code;

			log.info(selectSql);

			try {

				// log.info(StringUtils.center(" line ", 80, "*"));
				Object[] searchResult = runner.query(conn, selectSql,
						new ArrayHandler());

				// if(searchResult != null)
				// {h++;
				// continue;
				// }

				// 文本字段不为空，执行 update。 之后，原来的文本会变成游离态，需要删除
				// 如果是同一条题录，导入两次，文本名称是一个，此时不需要删除。
				// 应该靠定期机制删除游离态文件比较好

				if (searchResult != null) {

					// if (searchResult[1] != null)
					// delFileFromFtpServerSet.add(standard_code
					// + " , update 操作，现在的文件名称：" + text_address
					// + "，原来的文件名称->" + searchResult[1].toString());

					// 处理 remrk 字段，如果有了更新依据 "深圳国外数据 update"，就不再重复写了。
					if (searchResult[0] != null
							&& !searchResult[0].toString().equals("")) {

						String tempStr = searchResult[0].toString();

						// log.info(tempStr);

						if (!StringUtils.contains(tempStr, "深圳国外数据 update"))
							remarkString = ", remark =remark || ';深圳国外数据 update', ";

					}

					String updateSql = "update st_standard set " + "namecn ="
							+ namecn + ", nameen =" + nameen
							+ ", class_two_code =" + class_two_code
							+ ", class_one_code =" + class_one_code
							+ ", class_three_code =" + class_three_code
							+ ", status =" + status + ", issue_time ="
							+ issue_time + ", act_time =" + act_time
							+ ", cancel_time =" + cancel_time + ", ccs_code ="
							+ ccs_code + ", ics_code =" + ics_code + ", xgj ="
							+ xgj + ", replace_standard =" + replace_standard
							+ ", replaced_standard =" + replaced_standard
							+ ", reference_file =" + reference_file
							+ ", adopt_standard_code =" + adopt_standard_code
							+ ", topic =" + topic + ", language_code ="
							+ language_code + ", page_number =" + page_number
							+ ", lasted_user='ShenZhen',summary =" + summary
							+ ", lasted_modify_time =" + lasted_modify_time
							+ remarkString + "text_address =" + text_address
							+ " where standard_code=" + standard_code
							+ " and class_one_code ='GW'";

					/**
					 * 测试的时候用下面的打印语句，可以判断数据库更新之后的情况
					 * 
					 * 正式运行的时候关闭，用下面的语句。
					 * 
					 * 
					 */
					// countUpdate++;
					// log.info(updateSql);

					/**
					 * 
					 * 
					 * 测试时关闭下面语句
					 * 
					 * 
					 * 
					 * */
					int ri = 0;
					ri = runner.update(conn, updateSql);
					// 删除原有文本。深圳没有版本更新的概念，新的题录覆盖了旧的题录，所以应该删除
					if (ri == 1) {
						countUpdate++;
						log.info(updateSql);
					}
				}

				else // insert
				{

					String insertSql = "insert into st_standard ("
							+ "id,standard_code,namecn,nameen,class_one_code,class_two_code,class_three_code,"
							+ "status,issue_time,act_time,cancel_time,ccs_code,ics_code,xgj,replace_standard,replaced_standard,"
							+ "reference_file,adopt_standard_code,topic,language_code,page_number,summary,lasted_modify_time,text_address,lasted_user,remark) "
							+ "values("
							+ id
							+ ","
							+ standard_code
							+ ","
							+ namecn
							+ ","
							+ nameen
							+ ","
							+ class_one_code
							+ ","
							+ class_two_code
							+ ","
							+ class_three_code
							+ ","
							+ status
							+ ","
							+ issue_time
							+ ","
							+ act_time
							+ ","
							+ cancel_time
							+ ","
							+ ccs_code
							+ ","
							+ ics_code
							+ ","
							+ xgj
							+ ","
							+ replace_standard
							+ ","
							+ replaced_standard
							+ ","
							+ reference_file
							+ ","
							+ adopt_standard_code
							+ ","
							+ topic
							+ ","
							+ language_code
							+ ","
							+ page_number
							+ ","
							+ summary
							+ ","
							+ lasted_modify_time
							+ ","
							+ text_address
							+ "," + lasted_user + "," + "'深圳国外数据 insert'" + ")";

					/**
					 * 测试的时候用下面的打印语句，可以判断数据库更新之后的情况
					 * 
					 * 正式运行的时候关闭，用下面的语句。
					 * 
					 * 
					 */
					// countInsert++;
					// log.info(insertSql);

					/**
					 * 
					 * 
					 * 
					 * 测试时关闭下面语句
					 * 
					 * 
					 * 
					 * 
					 * */
					int rj = 0;
					rj = runner.update(conn, insertSql);

					if (rj == 1) {
						countInsert++;
						log.info(insertSql);
					}
				}

				finishedTiLu.add(lineValue);

			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
				DbUtils.closeQuietly(conn);
				return;
			}

			// log.info(StringUtils.center(" line ", 80, "*"));
			// log.info(updateSql);
			// log.info(insertSql);
			// out.println(updateSql);
			// out.println(insertSql);

			// 记录已经导入的题录，发生异常之后，再接着导入
			// 如果导入发生异常，根据此信息，可以找到导入的题录，不应删除，因为有更新的题录
			// select * from st_standard t where t.lasted_modify_time >
			// to_date('2010-07-01 14:00:00','yyyy-MM-dd hh24:mi:ss')

		}

		DbUtils.closeQuietly(conn);

		// 记录已经导入的题录，发生异常之后，再接着导入
		if (!finishedTiLu.isEmpty())
			try {
				FileUtils.writeLines(new File(finishedTiLuFile), finishedTiLu);
				if (!delFileFromFtpServerSet.isEmpty())
					FileUtils.writeLines(new File(shouldDeleteFile),
							delFileFromFtpServerSet);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		log.info("需要 update 的题录数量：" + countUpdate);
		log.info("需要 insert 的题录数量：" + countInsert);
		log.info("重新查重数量：" + h);

	}

	/**
	 * 导入国外修改单标准。国内标准由于逻辑不同，单独处理，不用此方法
	 * 
	 * 
	 * 
	 * @param onlybulFile
	 *            生成的修改单信息
	 */

	private void insertXGDToOracleGW(File onlybulFile) {

		List<String> li = null;

		// 保存已经导入的修改单
		Set<String> finishedXGD = new TreeSet<String>();

		int countInsert = 0;
		int countExist = 0;

		int n = 0;
		try {
			li = FileUtils.readLines(onlybulFile);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (li == null)
			return;

		// 逐条循环
		for (String lineValue : li) {

			boolean tag = false;

			// 测试10条数据，正式运行时去掉
			// n++;
			// if (n == 10)
			// break;
			// // 测试

			out.println(StringUtils.center(" line ", 80, "*"));

			// 如果字段值没有，会自动返回 null，不会影响 sql 语句执行
			// id
			String id = "seq_standard.nextval";

			// 标准号
			String standard_code = POIUtils.getColumValue(lineValue, 0);
			if (standard_code != null)
				standard_code = "'"
						+ SqlUtils.getInstance().getEscapeVale(standard_code)
						+ "'";

			// 实施日期
			String act_time = POIUtils.getColumValue(lineValue, 6);
			if (act_time != null)
				act_time = "to_date('"
						+ SqlUtils.getInstance().getEscapeVale(act_time)
						+ "','yyyy-mm-dd')";

			// 最后修改时间
			String lasted_modify_time = "sysdate";

			// 文本路径
			String text_address = this.getUpdateTextAddress(POIUtils
					.getColumValue(lineValue, 20));
			if (text_address != null)
				text_address = "'"
						+ SqlUtils.getInstance().getEscapeVale(text_address)
						+ "'";

			try {

				String selectTextaddress = "select t.file_address from st_modify t where t.standard_code ="
						+ standard_code;

				List<Object[]> searchResultTextaddress;

				searchResultTextaddress = runner.query(conn, selectTextaddress,
						new ArrayListHandler());

				log.info(standard_code + " : " + text_address);

				// 判断修改单文件名是否存在，如果存在，说明该记录已经入库
				// 文件名称是包含文件夹结构的，所以据此判断是合理的。
				// 避免了文本内容变化而文件名没有变的问题。
				String strTemp;
				for (Object[] ob : searchResultTextaddress) {
					strTemp = (String) ob[0];
					log.info("该标准已经经存在修改单，名称是 : " + strTemp);

					if (strTemp.equals(StringUtils.remove(text_address, '\''))) {
						tag = true;
						break;

					}
				}

				// 已经入库，跳过
				if (tag) {
					countExist++;
					log.info(text_address + " exist.");
					continue;
				}

				// 找到最大的修改单编号，如果不是第一个修改单，则在编号 +1
				int num = 1;
				String selectSql = "select max(t.modify_number) from st_modify t where t.standard_code ="
						+ standard_code;

				Object[] searchResult = runner.query(conn, selectSql,
						new ArrayHandler());

				for (Object o : searchResult) {

					log.info("修改单最大序号为 ：" + o);
				}

				if (searchResult == null || searchResult.length == 0)
					num = 1;

				else if (searchResult[0] == null)
					num = 1;
				else
					num = num + new Integer(searchResult[0].toString());

				String insertSql = "insert into st_modify ("
						+ "modify_id,standard_code,modify_number,act_time,lasted_modify_time,file_address,remark) "
						+ "values(" + id + "," + standard_code + "," + num
						+ "," + act_time + "," + lasted_modify_time + ","
						+ text_address + ", '深圳国外数据 insert')";

				log.info("insertSql :" + insertSql);

				/**
				 * 
				 * 
				 * 测试时关闭此语句
				 * 
				 * 
				 * 
				 * */
				// 更新
				runner.update(conn, insertSql);

			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				break;
			}

			countInsert++;

		}

		DbUtils.closeQuietly(conn);

		log.info("已经存在的 题录数量：" + countExist);
		log.info("需要 insert 的题录数量：" + countInsert);

	}

	/**
	 * 从最终需要导入的题录数据中，找相应的 pdf 文件路径并记录，准备从 ftp 中下载
	 * 
	 * 如果文本已经在本地，可以略过此方法
	 * 
	 * @param tiluFile
	 *            待导入的题录文件
	 * @param pdfNameFile
	 *            生成的 pdf 文件名称
	 */
	private void getPdfFileName(File tiluFile, File pdfNameFile) {

		List<String> tiluList = null;

		try {
			tiluList = FileUtils.readLines(tiluFile);

			if (tiluList == null)
				return;

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 存放找到的路径
		List<String> pdfFilelist = new ArrayList<String>();

		for (String lineValue : tiluList) {

			String excelFileName = POIUtils.getFileName(lineValue);
			String pdfFileName = POIUtils.getColumValue(lineValue, 20);

			if (pdfFileName == null)
				continue;

			String dayDirectory = "";
			String ftpPdfPath = "";

			// ===由于各个年份的文件名称标注不一样，分别处理
			// 2008 年情况
			if (StringUtils.startsWith(excelFileName, "08")) {

				dayDirectory = "2008."
						+ StringUtils.substring(excelFileName, 2, 4) + "/";

				ftpPdfPath = "/shenzhen/2008/foreign/" + dayDirectory
						+ pdfFileName;

				// 处理 08 年的特殊目录情况
				if (StringUtils.contains(pdfFileName.toLowerCase(), "/jjg/")
						|| StringUtils.contains(pdfFileName.toLowerCase(),
								"/jjf/"))
					ftpPdfPath = "/shenzhen/2008/native/" + dayDirectory
							+ pdfFileName;

			}

			// 2009 年情况
			if (StringUtils.startsWith(excelFileName, "09")) {

				// 合并的月份
				if (StringUtils.startsWith(excelFileName, "0902-03"))
					dayDirectory = "2009."
							+ StringUtils.substring(excelFileName, 2, 7) + "/";
				else
					dayDirectory = "2009."
							+ StringUtils.substring(excelFileName, 2, 4) + "/";

				ftpPdfPath = "/shenzhen/2009/foreign/" + dayDirectory
						+ pdfFileName;

				// 处理 09 年的特殊目录情况
				if (StringUtils.contains(pdfFileName.toLowerCase(), "/jjg/")
						|| StringUtils.contains(pdfFileName.toLowerCase(),
								"/jjf/"))
					ftpPdfPath = "/shenzhen/2009/native/" + dayDirectory
							+ pdfFileName;

			}
			// 2010 年情况
			if (StringUtils.startsWith(excelFileName, "10")) {

				dayDirectory = "2010."
						+ StringUtils.substring(excelFileName, 2, 4) + "/";

				ftpPdfPath = "/shenzhen/2010/" + dayDirectory + pdfFileName;

			}

			pdfFilelist.add(ftpPdfPath.replace('\\', '/'));

			// out.println(ftpPdfPath);

		}

		// 测试结果
		// POIUtils.testPrintExcelValue(set);

		// /shenzhen/2010/2010.01/

		try {

			FileUtils.writeLines(pdfNameFile, pdfFilelist);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 根据从题录中提取出来的文件路径，下载文件
	 * 
	 * 如果文本已经在本地，可以略过此方法
	 * 
	 * @param pdfNameFile
	 *            待下载的文件列表
	 */
	private void getPdfFilesFromFtpServer(File pdfNameFile) {

		// 初始化
		Ftp4jUtils ftpUtils = new Ftp4jUtils();

		FTPClient client = null;
		try {
			client = ftpUtils.getFTPClient("129.9.200.128", 21, "szread",
					"szread");
		} catch (IllegalStateException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		} catch (IOException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		} catch (FTPIllegalReplyException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		} catch (FTPException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}

		TreeSet<String> failSet = new TreeSet<String>();

		List<String> li = null;
		try {
			li = FileUtils.readLines(pdfNameFile);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (li != null)
			for (String ftpFilename : li) {

				// 得到标准类别，并创在本地建目录
				String localFileName = StringUtils.substringBeforeLast(
						ftpFilename, "/");
				// out.println(localFileName);
				localFileName = StringUtils.substringAfterLast(localFileName,
						"/");
				// out.println(localFileName);
				localFileName = "k:/sz2010/" + localFileName + "/";

				try {
					MyFileUtils.forceMkdir(new File(localFileName));
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}

				// 得到最终的本地文件名称
				File localFile = new File(localFileName
						+ StringUtils.substringAfterLast(ftpFilename, "/"));

				// out.println(ftpFilename);
				// out.println(localFileName);

				try {

					// 可能类别文件夹大小写不对，转换
					if (!ftpUtils.existsFile(client, ftpFilename)) {

						ftpFilename = StringUtils.substringBeforeLast(
								ftpFilename, "/").toLowerCase()
								+ "/"
								+ StringUtils.substringAfterLast(ftpFilename,
										"/");

						// 处理 2008，2009 年的文件夹特殊情况
						if (StringUtils.contains(ftpFilename.toLowerCase(),
								"/2008/")
								|| StringUtils.contains(
										ftpFilename.toLowerCase(), "/2009/")) {

							if (StringUtils.contains(ftpFilename.toLowerCase(),
									"/jjg/")
									|| StringUtils.contains(
											ftpFilename.toLowerCase(), "/jjf/"))

								ftpFilename = StringUtils.replace(ftpFilename,
										"foreign", "native");
						}

					}

					if (!localFile.exists() || localFile.length() == 0) {
						out.println("down file succeed :" + ftpFilename);
						client.download(ftpFilename, localFile);

					}

				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
					out.println("down file failed :" + ftpFilename);
					failSet.add(ftpFilename);
				}
			}

		ftpUtils.disconnectQuietly(client);

		if (!failSet.isEmpty()) {
			try {
				FileUtils.writeLines(new File(
						"d://shenzhen//downFileFailed.txt"), failSet);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * 用来规范深圳的不规范的代替代替标准号
	 * 
	 * @param shenZhenreplacedStandardCode
	 *            深圳不规范的标准号
	 * @return
	 */
	private String getReplacedStandardCodeFromShenZhen(
			String shenZhenreplacedStandardCode) {

		// 只规范下面几种情形：
		// GB/T 8967-2007;
		// SS GB/T 8967-2007

		shenZhenreplacedStandardCode = StringUtils.remove(
				shenZhenreplacedStandardCode, ";");
		int i = StringUtils.countMatches(shenZhenreplacedStandardCode, " ");
		if (i == 1)// 合法
			return shenZhenreplacedStandardCode;
		if (i > 1)// 取第一个空格后面的字符串
			return StringUtils
					.substringAfter(shenZhenreplacedStandardCode, " ");
		return "";

	}

	/**
	 * 查找非 pdf 格式的文件。深圳给的数据有一些是压缩文件，不是pdf文件，发现过一次。
	 * 
	 * 另外发现深圳给的数据，excel 文件中文本字段的文件夹是大写，但光盘中的文件夹却是小写
	 * 
	 * 所以，把文件名和文件夹名称，都统一改为大写。
	 * 
	 * @param rootDirectory
	 * @throws IOException
	 */
	private void findNoPDF(File rootDirectory) {

		File[] f = rootDirectory.listFiles();

		// rootDirectory -> J:\深圳数据\深圳更新\

		// ff -> J:\深圳数据\深圳更新\2010.06\ASTM\abc.pdf

		for (File ff : f) {

			// 文件名和文件夹名改为大写，含文件扩展名
			ff.renameTo(new File(ff.getParent() + "\\"
					+ ff.getName().toUpperCase()));

			if (ff.isFile()) {

				// log.info("name : " + ff.getName());
				// log.info("name : " + ff.getParent());

				String stemp = FilenameUtils.getExtension(ff.getName());

				if (stemp.equals("PDF") || stemp.equals("pdf")
						|| stemp.equals("XLS") || stemp.equals("xls")) {

					continue;

				} else {
					log.info(ff.getAbsolutePath() + " ");
					notPDF.add(ff.getAbsolutePath());
				}
			}

			else {
				// log.info("name : " + ff.getName());
				// log.info("Directory : " + ff.getAbsolutePath());
				findNoPDF(ff);
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ShenZhen sz = new ShenZhen();

		// System.out.println(sz.mod_bzh_simple("CS JB/T 7003-07(呵呵);PS JB/T 7003-07;SS JB/T 7003-07"));

		// 检查并规范深圳数据

		// 计算执行时间
		long startTime = System.currentTimeMillis(); // 获取开始时间

		// 步骤零:
		// 1. 在运行的时候，一定要在 plsql 工具中，把 oracle 的视图、序列和触发器打开，查看其是否可以工作。

		// 2. 先关闭 gateway，执行完毕后，再开启 gateway 统一执行

		// 步骤一:
		// 查找非 pdf 格式的文件。有一次发现，深圳给的数据有一些压缩文件
		// 找到之后，同时要修改 excel 文件中的记录

		// 同时把文件名改为大写，路径中不要包含中文，否则修改文件名不成功
		sz.writeNoPDF(new File("I:\\decryptPdfDir"));

		// 步骤二:
		// 得到题录文件
		// sz.creatTiluTXTFromExcelFiles();

		// 步骤三:
		// 插入最新的国际标准。
		// 在正式运行前，关闭数据库操作语句进行测试，检查 sql 文件没有问题后再进行操作。
		// 检查触发器，关闭gateway
		// sz.insertToOracleGW(new File("D:\\00\\new_tilu_0.txt"));
		// sz.insertToOracleGW(new File(sz.new_tilu));

		// 步骤四:
		// 插入修改单
		// sz.insertXGDToOracleGW(new File(sz.exception_onlybul_tilu));

		// 步骤五:
		// ftp 导入文件到 IB2

		// 步骤六:
		// 最后，删除导入的 sae 题录，参见： 国外标准版权问题处理.sql

		long endTime = System.currentTimeMillis(); // 获取结束时间

		System.out.println("程序运行时间： " + (endTime - startTime) / 1000 + "s");

	}
}